home *** CD-ROM | disk | FTP | other *** search
/ LiquidLibrary 2005 February / LiquidLibrary 2005 February - Disc 1.iso / pc / Portfolio Browser / Filters / PDF / LIB / pdf_font.ps < prev    next >
Text File  |  2003-01-03  |  31KB  |  946 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is licensed to a single customer by Artifex Software Inc.
  4. % under the terms of a specific OEM agreement.
  5.  
  6. % $RCSfile$ $Revision$
  7. % pdf_font.ps
  8. % PDF font operations.
  9.  
  10. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  11. .currentglobal true .setglobal
  12. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  13. GS_PDF_ProcSet begin
  14. pdfdict begin
  15.  
  16. % We cache the PostScript font in an additional element of the
  17. % font resource dictionary, called PSFont.
  18.  
  19. % ---------------- Encodings ---------------- %
  20.  
  21. % Apply a list of differences to an Encoding.
  22. % Note that the differences may cause the array to grow.
  23. /updateencoding {    % <encoding> <differences> updateencoding <enc'>
  24.     % Calculate the length of the result.
  25.   exch 0 2 index {
  26.     dup type /nametype ne { exch pop } { pop 1 add } ifelse
  27.   } forall
  28.   1 index length .max array dup 0 4 -1 roll putinterval
  29.   exch 0 exch {
  30.         % Stack: enc' code element
  31.     dup type /nametype ne
  32.       { exch pop }
  33.       { 3 copy put pop 1 add }
  34.     ifelse
  35.   } forall pop
  36. } bdef
  37.  
  38. % Get the Encoding for a font.
  39. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  40.  { /Encoding knownoget
  41.     { dup type /nametype eq
  42.        { 
  43.          % The published PDF specification says the Encoding name
  44.          % "must be" one of the 3 predefined Encodings, implying
  45.          % that an error should occur if it isn't.  However, Acrobat
  46.          % Reader simply ignores unknown names, and since there are
  47.          % some buggy applications that rely on this, we do the same.
  48.  
  49.          dup dup dup /MacRomanEncoding eq
  50.          exch /MacExpertEncoding eq or 
  51.          exch /WinAnsiEncoding eq or
  52.            { exch pop findencoding
  53.            }
  54.            { pop
  55.            }
  56.          ifelse
  57.        }
  58.        { dup /BaseEncoding knownoget
  59.       { findencoding 3 -1 roll pop exch
  60.       }
  61.      if
  62.      /Differences knownoget { updateencoding } if
  63.        }
  64.       ifelse
  65.     }
  66.    if
  67.  } bdef
  68.  
  69. % Rename a font with a generated name.
  70. /renamefont {        % <fontdict> renamefont <font'>
  71.   dup /FontName 2 copy get genfontname dup 5 1 roll put definefont
  72. } bind def
  73.  
  74. % Adjust a font according to the Encoding and Widths in the font resource.
  75. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  76.   getfontencoding
  77.   getfontmetrics 4 -1 roll pop .updatefont { renamefont } if
  78. } bind def
  79.  
  80. % Get the (possibly modified) encoding of a font.
  81. /getfontencoding {    % <font-resource> <font> getfontencoding
  82.             %   <font-resource> <font> <Encoding|null>
  83.   1 index /Encoding known {
  84.     dup /Encoding .knownget { 2 index getencoding } { null } ifelse
  85.   } {
  86.     null
  87.   } ifelse
  88. } bdef
  89.  
  90. /find_in_diff     % <Differences> <index> find_in_diff <bool>
  91. { false exch 0 4 3 roll
  92.   { dup type /nametype ne { exch pop } { pop 1 add } ifelse
  93.     2 copy eq {
  94.       pop pop pop true 0 0 exit
  95.     } if
  96.   } forall
  97.   pop pop
  98. } bdef
  99.  
  100. % Get the metrics of a font, if specified.
  101. /getfontmetrics {    % <font-resource> <font> <Encoding|null> getfontmetrics
  102.             %   <font-resource> <font> <Encoding|null>
  103.             %   <Metrics|null>
  104.   2 index /Widths known {
  105.     dup null eq { pop dup /Encoding get } if
  106.     4 dict begin
  107.       /Encoding exch def
  108.       /Metrics Encoding length dict def
  109.       exch
  110.       dup /Widths oget /Widths exch def
  111.         % Stack: font font-res
  112.         % Note that widths are always based on a 1000-unit
  113.         % character space, but the FontMatrix may specify
  114.         % some other scale factor.  Compensate for this here,
  115.         % by scaling the Widths if necessary.
  116.       0.001 2 index /FontMatrix get 0 get div
  117.         % Stack: font font-res mscale
  118.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  119.        {    % Stack: font font-res mscale first-char index
  120.      Encoding 1 index get
  121.      Widths 2 index 4 index sub oget
  122.          % Stack: font font-res mscale first-char index charname width
  123.      4 index mul
  124.         % The following 'loop' is only context for 'exit'.
  125.      {    
  126.         % Work around a bug in pdfTeX, which can generate Encoding
  127.         % vectors containing nulls :
  128.        1 index null eq { exit } if
  129.         % There is a hack here to deal with encodings where the
  130.         % same character appears more than once, because the Metrics
  131.         % dictionary works by character name, not by character code.
  132.         % We prefer to take (1) non-zero width, and (2) width for 
  133.         % the character code which appears in Differences.
  134.        Metrics 2 index .knownget not { 0 } if 0 ne {
  135.          5 index /Encoding knownoget not { exit } if
  136.          dup type /dicttype ne { pop exit } if
  137.          /Differences knownoget not { exit } if
  138.          3 index //find_in_diff exec not { exit } if
  139.        } if
  140.        2 copy Metrics 3 1 roll put
  141.        exit
  142.      } loop
  143.      pop pop pop
  144.        }
  145.       for pop
  146.         % Now fill in the MissingWidth for any encoded characters
  147.         % that aren't in Metrics already.  Note that built-in
  148.         % fonts may have Widths/FirstChar/LastChar but no
  149.         % FontDescriptor, so we must check for this.
  150.         % Stack: font font-res mscale
  151.       1 index /FontDescriptor knownoget {
  152.     Metrics exch
  153.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  154.     Encoding {
  155.         % Stack: font font-res mscale missing-width metrics charname
  156.         % Work around the abovementioned pdfTeX bug.
  157.       dup null ne {
  158.         2 copy known not { 2 copy 4 index put } if pop
  159.       } {
  160.         pop
  161.       } ifelse
  162.     } forall pop pop pop
  163.       } {
  164.     pop
  165.       } ifelse
  166.     exch Encoding Metrics end
  167.   } {
  168.     null
  169.   } ifelse
  170. } bdef
  171.  
  172. currentdict /find_in_diff undef
  173.  
  174. % ---------------- Descriptors ---------------- %
  175.  
  176. % Partial descriptors for the 14 built-in fonts.  Note that
  177. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  178. % object has undergone a subtle change in its meaning which has serious
  179. % consequences for searching with Acrobat:
  180. % In PDF 1.1, the flag meant: Font has StandardEncoding
  181. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  182. /standardfontdescriptors mark
  183.   /Courier mark /Flags 16#23 .dicttomark
  184.   /Courier-Oblique 1 index
  185.   /Courier-Bold 1 index
  186.   /Courier-BoldOblique 1 index
  187.   /Helvetica mark /Flags 16#20 .dicttomark
  188.   /Helvetica-Oblique 1 index
  189.   /Helvetica-Bold 1 index
  190.   /Helvetica-BoldOblique 1 index
  191.   /Times-Roman mark /Flags 16#22 .dicttomark
  192.   /Times-Bold 1 index
  193.   /Times-Italic mark /Flags 16#62 .dicttomark
  194.   /Times-BoldItalic 1 index
  195.   /Symbol mark /Flags 16#4 .dicttomark
  196.   /ZapfDingbats 1 index
  197. .dicttomark readonly def
  198.  
  199. % ---------------- Utilities ---------------- %
  200.  
  201. % Fabricate a font name by adding ?'s on the end.
  202. /genfontname        % <name> genfontname <name>
  203.  { dup length string cvs
  204.     { (?) concatstrings
  205.       dup cvn FontDirectory exch known not { cvn exit } if
  206.     }
  207.    loop
  208.  } bdef
  209.  
  210. % Find a font, and adjust its encoding if necessary.
  211. /.pdfdfndict mark
  212.   /defaultfontname /Helvetica
  213. .dicttomark readonly def
  214. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  215.         % If the font isn't available, synthesize one based on
  216.         % its descriptor.
  217.   dup /Font resourcestatus {
  218.     pop pop findfont
  219.   } {
  220.     1 index /FontDescriptor knownoget {
  221.         % Stack: font-res fontname fontdesc
  222.       dup /Flags oget
  223.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  224.       1 index 16#40000 and -17 bitshift add    % 2, bold
  225.       exch 16#2 and 2 bitshift add    % 8, serif
  226.         % We should look at the fixed flag, too.
  227.         % Stack: font-res fontname fontdesc properties
  228.       1 index /FontName oget exch
  229.         % Analyzes font name and extract "Narrow" property
  230.         % which is not described by the FontDescriptor Flags.
  231.       0 2 index .fontnameproperties 4 and or
  232.         % Rebind the default font name to Helvetica so that
  233.         % fonts with no properties are handled correctly.
  234.       //.pdfdfndict begin .substitutefontname end
  235.         % Stack: font-res fontname fontdesc substname|null
  236.       Fontmap 1 index known not {
  237.         % No available good substitution, use the standard one.
  238.     pop 1 index .substitutefont
  239.       } if
  240.       QUIET not {
  241.     (Substituting font ) print dup =only
  242.     ( for ) print 2 index =only (.) = flush
  243.       } if
  244.       3 -1 roll pop findfont
  245.         % Stack: font-res fontdesc font
  246.         % If this is a small-caps font, replace the CharString
  247.         % entries for a..z.
  248.       exch /Flags oget 16#20000 and 0 ne {
  249.     true .copyfontdict
  250.     dup /CharStrings 2 copy get dup length dict .copydict
  251.     4 index /FirstChar get 97 .max
  252.     5 index /LastChar get 122 .min 1 exch {
  253.         % Stack: font-res font' font' /CharStrings charstrings code
  254.         % Note that this only remaps a-z, not accented characters.
  255.       5 index /Widths oget 1 index 7 index /FirstChar get sub oget
  256.       1 string dup 0 5 -1 roll put
  257.         % Stack: font-res font' font' /CharStrings charstrings code
  258.         %   width (x)
  259.       2 index exch dup cvn exch
  260.       dup 0 2 copy get 32 sub put 4 -1 roll {
  261.             % Stack: operand (X) width
  262.         0 setcharwidth exch pop
  263.         currentfont /FontMatrix get matrix invertmatrix concat
  264.         0.7 dup scale 0 0 moveto show
  265.       } /exec cvx 4 packedarray cvx put
  266.     } for put
  267.     renamefont
  268.       } if
  269.     } {
  270.         % No descriptor available, use the default algorithm.
  271.       findfont
  272.     } ifelse
  273.   } ifelse adjustfont
  274. } bdef
  275.  
  276. % ---------------- Type 1 fonts ---------------- %
  277.  
  278. /buildType1        % <Type1-font-resource> buildType1 <font>
  279.  { dup /BaseFont get pdffindfont
  280.  } bdef
  281.  
  282. % The state dictionary for the embedded Type 1 font reading procedure
  283. % has the following keys and values:
  284. %    data - stream (filter)
  285. %    buffer, buffer2 - string
  286. %    hexify - procedure to convert buffer to hex if needed
  287. %    leftstr - string containing (non-negative) integer
  288. %    sectionstr - string containing a character 0 .. 3
  289. %    stream - (stream) dictionary
  290. %    proc - procedure of the form {-dict- type1read}
  291. %       pfbhdr - string containing 16#80 if PFB, 0 otherwise
  292. % When the procedure is executing, this dictionary is current.
  293. % leftstr and sectionstr are strings so that we can change their values
  294. % reliably in case the font executes a restore!
  295. % We also have to do something special about embedded fonts that
  296. % execute definefont more than once -- that is the function of topFontDict.
  297.  
  298. % Read an embedded Type 1 font.
  299. /readfontfilter {    % <proc> readfontfilter <filter>
  300.   0 () /SubFileDecode filter
  301. } bdef
  302. /readtype1dict 5 dict dup begin
  303.   /definefont {
  304.     dup topFontDict eq topFontDict null eq or {
  305.       dup wcheck not { dup length dict copy } if
  306.       exch pop savedFontName exch
  307.     } if
  308.     //systemdict /definefont get exec
  309.   } bdef
  310.   /eexec {
  311.     % Assume the font dictionary is directly below the file on the stack
  312.     count 0 gt { /topFontDict 2 index cvlit store } if
  313.     55665 /eexecDecode filter
  314.     //systemdict begin readtype1dictcopy begin cvx stopped
  315.     currentdict readtype1dictcopy eq { end } if
  316.     currentdict //systemdict eq { end } if
  317.      { stop } if
  318.   } bdef
  319. end readonly def
  320. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  321.         % Read the definition, using a procedure-based filter
  322.         % that turns binary/hex conversion on and off
  323.         % at the right times.
  324.    1 index exch
  325.    PDFfile fileposition 3 1 roll
  326.    11 dict begin
  327.      /leftstr (          ) 10 string copy def
  328.        dup /Length1 oget leftstr cvs pop
  329.      /sectionstr <00> 1 string copy def
  330.      /pfbhdr <00> 1 string copy def
  331.      /stream 1 index def
  332.      true resolvestream /data exch def
  333.      /buffer 1000 string def        % arbitrary
  334.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  335.      /hexify /buf2hex load def
  336.    currentdict end
  337.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  338.    readfontfilter
  339.         % Some buggy embedded fonts leave extra junk on the stack,
  340.         % so we have to make a closure that records the stack depth
  341.         % in a fail-safe way.
  342.    //systemdict begin
  343.         % The PDF specification is somewhat muddy about whether
  344.         % an embedded font's name is supposed to be the BaseFont
  345.         % from the Font object or the FontName from the descriptor.
  346.         % Acrobat Distiller requires the former.  Save away the
  347.         % name so we can substitute it at definefont time.
  348.    //readtype1dict dup length 3 add dict copy begin
  349.    1 index /BaseFont oget /savedFontName exch def
  350.    /topFontDict null def
  351.    /readtype1dictcopy currentdict def
  352.     { run } aload pop count 1 sub 2 packedarray cvx exec
  353.    end end
  354.    count exch sub { pop } repeat
  355.    PDFfile 3 -1 roll setfileposition
  356.    /BaseFont oget findfont
  357.    adjustfont
  358.  } bdef
  359.  
  360. % Execute the appropriate reading procedure.
  361. /type1read        % <dict> type1read <string>
  362.  { begin leftstr cvi
  363.     { type1read0 type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  364.    (          ) leftstr copy cvs pop end
  365.  } bdef
  366.  
  367. % Read the next block of data into the buffer.
  368. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  369.  { 0 2 index 2 index length min getinterval
  370.         % Adobe requires readstring to signal an error if given
  371.         % an empty string.  Work around this nonsense here.
  372.    dup length 0 ne { data exch readstring pop } if
  373.    dup length 3 -1 roll exch sub
  374.    DEBUG
  375.     { dup =only ( read ) print
  376.       1 index length =only (: ) print
  377.       1 index == flush
  378.     } if
  379.  } bdef
  380.  
  381. % Read the initial byte to see if we need to skip a 6 byte PFB header
  382. /type1read0 {         % <left> type1read0 <string> <left'>
  383.   sectionstr 0 1 put    % either way we go to the next stage
  384.   pfbhdr type1readdata
  385.   1 index 0 get 16#80 eq {
  386.     (\n   **** Warning: Embedded Type1 font in PFB format is not valid PDF.)
  387.     pdfformaterror
  388.     DEBUG { (skipping PFB header) = flush } if
  389.     exch pop buffer 0 5 getinterval type1readdata exch
  390.     dup 4 get 256 mul 1 index 3 get add 256 mul
  391.     1 index 2 get add 256 mul 1 index 1 get add
  392.     DEBUG { (PFB segment length = ) print dup = } if
  393.     exch pop  % discard the string keeping the PFB segment length
  394.     2 copy ne {
  395.       (\n   **** Warning: Type 1 PFB segment length and Length 1 value do not match.)
  396.       pdfformaterror
  397.       exch     % keep the PFB length instead
  398.     } if
  399.     pop
  400.     buffer type1readdata    % go ahead and read a block
  401.   }
  402.   if    % if not PFB, return pfbhdr string (first char of file, usually %).
  403. } bdef
  404.  
  405. % Read the next block of the initial text portion.
  406. /type1read1 {        % <left> type1read1 <string> <left'>
  407.   DEBUG { (read1 ) print } if
  408.   dup 0 eq {
  409.     pop sectionstr 0 2 put
  410.     stream /Length2 oget
  411.             % Determine whether to hexify data for eexec.
  412.     dup 8 lt {
  413.       type1read2    % Hexify.
  414.     } {
  415.       DEBUG { (read2 ) print } if
  416.       pfbhdr 0 get 16#80 eq {
  417.         % eat 6 more bytes of PFB junk before proceeding
  418.     DEBUG { (skipping PFB header in segment 2) = flush } if
  419.     buffer 0 6 getinterval type1readdata exch
  420.         dup 5 get 256 mul 1 index 4 get add 256 mul
  421.     1 index 3 get add 256 mul 1 index 2 get add
  422.         DEBUG { (PFB segment length = ) print dup = } if
  423.     exch pop  % discard the string keeping the PFB segment length
  424.     2 copy ne {
  425.           (\n   **** Warning: Type 1 PFB segment length and Length 2 value do not match.)
  426.           pdfformaterror
  427.       dup =
  428.       exch         % keep the PFB length instead
  429.     } if
  430.       pop
  431.       } if
  432.       buffer2 type1readdata exch
  433.             % The check doesn't have to be 100% accurate:
  434.             % hexifying is always OK.
  435.       dup 0 8 getinterval 0 exch { or } forall
  436.       128 ge {
  437.     /hexify { } store
  438.     /buffer2 buffer def    % We don't need an intermediate buffer.
  439.       } if hexify exch
  440.     } ifelse
  441.   } {
  442.     buffer type1readdata
  443.   } ifelse
  444. } bdef
  445.  
  446. % Convert a string from binary to hex for eexec.
  447. % Free variables: buffer.
  448. /buf2hex {        % <string> buf2hex <hexstring>
  449.   buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  450.   buffer (>) search pop exch pop exch pop
  451. } bdef
  452.  
  453. % Read the next block of the encrypted portion.
  454. /type1trailer
  455. (0000000000000000000000000000000000000000000000000000000000000000\n\
  456. 0000000000000000000000000000000000000000000000000000000000000000\n\
  457. 0000000000000000000000000000000000000000000000000000000000000000\n\
  458. 0000000000000000000000000000000000000000000000000000000000000000\n\
  459. 0000000000000000000000000000000000000000000000000000000000000000\n\
  460. 0000000000000000000000000000000000000000000000000000000000000000\n\
  461. 0000000000000000000000000000000000000000000000000000000000000000\n\
  462. 0000000000000000000000000000000000000000000000000000000000000000\n\
  463. cleartomark\n)
  464. readonly def
  465. /type1read2 {        % <left> type1read2 <string> <left'>
  466.   DEBUG { (read2 ) print } if
  467.    dup 0 eq
  468.     { pop sectionstr 0 3 put
  469.       stream /Length3 oget
  470.       dup 0 eq
  471.        { DEBUG { (trailer ) print } if
  472.      type1trailer exch
  473.        }
  474.        { 
  475.          pfbhdr 0 get 16#80 eq {
  476.            % eat 6 more bytes of PFB junk before proceeding
  477.        DEBUG { (skipping PFB header in segment 3) = flush } if
  478.        buffer 0 6 getinterval type1readdata exch
  479.            dup 5 get 256 mul 1 index 4 get add 256 mul
  480.        1 index 3 get add 256 mul 1 index 2 get add
  481.            DEBUG { (PFB segment length = ) print dup = } if
  482.        exch pop  % discard the string keeping the PFB segment length
  483.        2 copy ne {
  484.            (\n   **** Warning: Type 1 PFB segment length and Length 3 value do not match.)
  485.            pdfformaterror
  486.          exch     % keep the PFB length instead
  487.        } if
  488.        pop
  489.        (\n) pdfformaterror
  490.          } if
  491.          type1read3
  492.        }
  493.       ifelse
  494.     }
  495.     { buffer2 type1readdata exch hexify exch
  496.     }
  497.    ifelse
  498. } bdef
  499.  
  500. % Read the next block of the final text portion.
  501. % When finished, this procedure returns an empty string.
  502. /type1read3        % <left> type1read3 <string> <left'>
  503.  { DEBUG { (read3 ) print } if
  504.    buffer type1readdata
  505.  } bdef
  506.  
  507. % ---------------- Type 3 fonts ---------------- %
  508.  
  509. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  510.  
  511. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  512.   8 dict begin
  513.     /FontType 3 def
  514.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  515.     /FontBBox 1 index /FontBBox get cvx def
  516.     /FontMatrix 1 index /FontMatrix oget def
  517.     /CharProcs 1 index /CharProcs oget def
  518.     1 index /Widths knownoget {
  519.       /Widths exch def
  520.       /FirstChar 1 index /FirstChar oget def
  521.       /LastChar 1 index /LastChar oget def
  522.     } if
  523.     /FontName 1 index /Name get genfontname def
  524.     /Encoding .notdefEncoding 2 index getencoding def
  525.         % We have to define BuildChar rather than BuildGlyph:
  526.         % there is no PDF equivalent of glyphshow, and we need
  527.         % the character code to access the Widths.
  528.     /BuildChar {
  529.         % Stack: font charcode
  530.       1 index begin 3 dict begin
  531.       /Font 3 -1 roll def /CharCode 1 index def
  532.       % Make unknown characters map to /.notdef
  533.       Encoding exch get dup CharProcs exch known
  534.         { CharProcs exch oget }
  535.     { pop CharProcs /.notdef oget }
  536.       ifelse
  537.       PDFfile fileposition exch
  538.       false resolvestream
  539.         % Stack: filepos stream
  540.         % Don't let setgcolor set the color inside the BuildGlyph
  541.         % procedure, because this causes an /undefined error.
  542.       q null /FillColor gput null /StrokeColor gput
  543.       Font /Resources get exch pdfopdict .pdfruncontext
  544.       Q
  545.       PDFfile exch setfileposition
  546.       end end
  547.     } bdef
  548.     FontName currentdict end definefont exch pop
  549. } bdef
  550. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  551.   /Widths where {
  552.     begin
  553.     CharCode FirstChar ge CharCode LastChar le and {
  554.       exch pop Widths CharCode FirstChar sub get exch
  555.     } if end
  556.   } if
  557. } bdef
  558.  
  559. % ---------------- TrueType fonts ---------------- %
  560.  
  561. /TTfonts mark
  562.   /Arial /Helvetica
  563.   /Arial,Italic /Helvetica-Oblique
  564.   /Arial,Bold /Helvetica-Bold
  565.   /Arial,BoldItalic /Helvetica-BoldOblique
  566.   /CourierNew /Courier
  567.   /CourierNew,Bold /Courier-Bold
  568.   /TimesNewRoman /Times-Roman
  569.   /TimesNewRoman,Italic /Times-Italic
  570.   /TimesNewRoman,Bold /Times-Bold
  571.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  572. .dicttomark readonly def
  573.  
  574. /buildTrueType {    % <TrueType-font-resource> buildTrueType <font>
  575.   dup /BaseFont get
  576.   dup TTfonts exch .knownget {
  577.     exch pop
  578.         % Hack required by the PDF specification: if the
  579.         % font resource has Subtype = /TrueType but the actual
  580.         % (installed) font is not a TrueType font, ignore the
  581.         % Encoding in the font resource.  However, all current
  582.         % versions of Acrobat Reader have the 14 base TrueType
  583.         % fonts built in, so this produces incorrect output for
  584.         % badly designed PDF files that specify these file names
  585.         % with /Subtype = /TrueType but no embedded definition.
  586.         % Compensate for this by removing the /Subtype key when
  587.         % looking up the font.
  588.     exch dup length dict copy dup /Subtype null put exch
  589.   } if pdffindfont
  590. } bdef
  591.  
  592. % Read an embedded TrueType font.
  593. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  594.         % This is much simpler than readtype1, because we don't
  595.         % have to deal with the tripartite .PFB format.
  596.   1 index exch
  597.   PDFfile fileposition 3 1 roll
  598.   true resolvestream readfontfilter
  599.         % Stack: filepos fontres stream
  600.   1 index /Subtype get /CIDFontType2 eq {
  601.     .loadttcidfont
  602.         % Stack: filepos fontres cidfont
  603.     1 index /CIDToGIDMap knownoget {
  604.       dup /Identity eq {
  605.     pop
  606.       } {
  607.     true resolvestream
  608.         % The following doesn't work for CIDToGIDMaps with more
  609.         % than 32K-1 entries.  We'll fix it later if necessary.
  610.         % Stack: filepos fontres font mapstream
  611.     dup 2 index /CIDCount oget 2 mul string readstring pop exch closefile
  612.     exch dup length 5 add dict .copydict
  613.     dup /FID undef
  614.     dup /CIDMap 4 -1 roll put
  615.     dup /CIDFontName get exch /CIDFont defineresource
  616.       } ifelse
  617.     } if
  618.   } {
  619.     null 2 index getencoding .loadpdfttfont
  620.   } ifelse
  621.   exch pop
  622.   PDFfile 3 -1 roll setfileposition
  623.         % Ignore both the Encoding and the Widths.
  624.   exch pop
  625. } bdef
  626.  
  627. % ---------------- Type 0 fonts ---------------- %
  628.  
  629. % Predefine the known CMaps, but only create them on demand.
  630. /knownCMaps mark
  631.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  632.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  633. .dicttomark def
  634.  
  635. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  636.   .currentglobal true .setglobal 3 1 roll
  637.   /CIDInit /ProcSet findresource begin
  638.   12 dict begin
  639.     begincmap
  640.     /WMode exch def
  641.     /CMapName exch def
  642.     /CIDSystemInfo 3 dict dup begin
  643.       /Registry (Adobe) def
  644.       /Ordering (Identity) def
  645.       /Supplement 0 def
  646.     end def
  647.     %/CMapName (see above)
  648.     /CMapVersion 1 def
  649.     /CMapType 1 def
  650.     %WMode (see above)
  651.     % The PDF documentation says that these CMaps map CIDs
  652.     % "1 to 65,536".  This is a misprint for 0 to 65,535.
  653.     1 begincodespacerange
  654.     % <0001> <00ff>  <0100> <ffff>
  655.       <0000> <ffff>
  656.     endcodespacerange
  657.     1 begincidrange
  658.     % <0001> <00ff> 1   <0100> <ffff> 256
  659.       <0000> <ffff> 0
  660.     endcidrange
  661.     endcmap
  662.     CMapName currentdict /CMap defineresource
  663.     knownCMaps CMapName 2 index put
  664.   end        % CMap
  665.   end        % CIDInit ProcSet
  666.   exch .setglobal
  667. } bdef
  668.  
  669. /buildType0 {        % <Type0-font-resource> buildType0 <font>
  670.   dup /BaseFont get    % FontName
  671.   1 index /Encoding oget
  672.   dup type /nametype eq {
  673.     dup /CMap resourcestatus {
  674.     pop pop /CMap findresource
  675.     } {
  676.     knownCMaps 1 index .knownget
  677.       { exch pop exec } { /undefined signalerror } ifelse
  678.     } ifelse
  679.   } {
  680.     PDFfile fileposition exch
  681.     dup /CMapName get exch true resolvestream cvx exec
  682.     /CMap findresource
  683.     exch PDFfile exch setfileposition
  684.   } ifelse        % CMap
  685.   [
  686.     3 index /DescendantFonts oget { exec resourcefont } forall
  687.   ]            % subfonts
  688.   composefont
  689.         % Stack: fontres font
  690.   1 index /FontMatrix knownoget {
  691.     dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
  692.       1 index exch makefont exch /FontName get exch definefont
  693.     } {
  694.       pop
  695.     } ifelse
  696.   } if exch pop
  697. } bdef
  698.  
  699. % ---------------- CIDFontType0/2 fonts ---------------- %
  700.  
  701. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  702. % arrays and using a (currently very inefficient) CDevProc.
  703. /addCIDmetrics {    % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
  704.   dup length 5 add dict .copydict
  705.   dup /FID undef
  706.   dup /UniqueID undef
  707.   dup /XUID undef
  708.     % Insert the widths into the font.
  709.   {W W2 DW DW2} {
  710.     % Stack: pdfresource newfont key
  711.     2 index 1 index .knownget {
  712.       2 index 3 1 roll put
  713.     } {
  714.       pop
  715.     } ifelse
  716.   } forall
  717.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  718.   exch pop
  719. } bdef
  720.  
  721. % Apply the [D]W[2] metrics to a character before displaying.
  722. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  723.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  724.             %   <w0x'> ... <vy'>
  725.   begin
  726.     % Look up and apply [D]W
  727.   10 index
  728.   currentdict /DW .knownget { 1000 div exch pop } if
  729.   currentdict /W .knownget {
  730.     % Search the W array for the CID.
  731.     % ****** NOT IMPLEMENTED YET ******
  732.     pop
  733.   } if
  734.   0 13 2 roll 11 -2 roll pop pop
  735.     % Look up and apply [D]W2
  736.     % ****** NOT IMPLEMENTED YET ******
  737.   pop end
  738. } bdef
  739. % <string> <match> tailmatch ==> <pre> true
  740. %                            ==> <string> false
  741. /tailmatch {
  742.   2 copy length 1 index length min
  743.   dup 2 index length exch sub exch getinterval
  744.   1 index eq {
  745.     length 1 index length exch sub
  746.     0 exch getinterval true
  747.   } {
  748.     pop false
  749.   } ifelse
  750. } bind def
  751.  
  752. /makeboldfont {
  753.   16 dict begin
  754.     /strokewidth exch def
  755.     /basecidfont exch def
  756.     /FontMatrix [ 1 0 0 1 0 0 ] def
  757.  
  758.     /CIDFontName /.boldfont def
  759.     /CIDFontType 1 def
  760.  
  761.     /basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def
  762.     /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def
  763.  
  764.     /CIDSystemInfo dup basecidfont exch get def
  765.     /FontBBox [ basecidfont /FontBBox get cvx exec
  766.       4 2 roll basecidfont /FontMatrix get transform
  767.       4 2 roll basecidfont /FontMatrix get transform
  768.     ] def
  769.  
  770.     /tmpstr 2 string def
  771.     /BuildGlyph {
  772.       gsave
  773.       exch begin
  774.         dup 256 idiv tmpstr exch 0 exch put
  775.         256 mod tmpstr exch 1 exch put
  776.         rootfont /WMode known { rootfont /WMode get 1 eq } { false } ifelse
  777.         { basefont-V } { basefont-H } ifelse setfont
  778.         strokewidth setlinewidth
  779.         1 setlinejoin
  780.         newpath
  781.         0 0 moveto tmpstr false charpath stroke
  782.         0 0 moveto tmpstr show
  783.         currentpoint setcharwidth
  784.       end
  785.       grestore
  786.     } bind def
  787.  
  788.    currentdict
  789.   end
  790.   dup /CIDFontName get exch /CIDFont defineresource
  791. } bind def
  792.  
  793. % <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> <font>
  794. %   CIDFont-resource is not modified.
  795. /findCIDFont {
  796.   {
  797.     dup /CIDFont resourcestatus {
  798.       pop pop /CIDFont findresource
  799.       exit
  800.     } if
  801.  
  802.     dup dup length string cvs
  803.     (,Bold) tailmatch {
  804.       exch pop
  805.       cvn findCIDFont 0.03 makeboldfont
  806.       exit
  807.     } if
  808.     (,Italic) tailmatch {
  809.       exch pop
  810.       cvn findCIDFont
  811.       [ 1 0 0.3 1 0 0 ] makefont
  812.       exit
  813.     } if
  814.     (,BoldItalic) tailmatch {
  815.       exch pop
  816.       cvn findCIDFont 0.03 makeboldfont
  817.       [ 1 0 0.3 1 0 0 ] makefont
  818.       exit
  819.     } if
  820.     pop
  821.  
  822.     1 index /CIDSystemInfo get begin Registry (-) Ordering end
  823.     concatstrings concatstrings
  824.     cvn
  825.     QUIET not {
  826.       (Substituting ) print dup ==only
  827.       ( for ) print 1 index ==only (.\n) print
  828.     } if
  829.     exch pop
  830.     /CIDFont findresource
  831.     exit
  832.   } loop
  833. } bdef
  834.  
  835. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  836.   dup /BaseFont get exch 1 index findCIDFont
  837.   addCIDmetrics /CIDFont defineresource
  838. } bdef
  839.  
  840. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  841.   dup /BaseFont get exch 1 index findCIDFont
  842.   addCIDmetrics /CIDFont defineresource
  843. } bdef
  844.  
  845. % ---------------- Other embedded fonts ---------------- %
  846.  
  847. /fontloadprocs mark
  848.   /Type1C /readType1C cvx
  849.   /CIDFontType0C /readCIDFontType0C cvx
  850. .dicttomark readonly def
  851.  
  852. % Read an embedded compressed font.
  853. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  854.   1 index exch
  855.   PDFfile fileposition 3 1 roll
  856.   dup true resolvestream dup readfontfilter
  857.         % Stack: pos resource streamdict stream filter
  858.   3 index /FontDescriptor oget /FontName oget
  859.   1 index FRD
  860.   closefile closefile pop
  861.   PDFfile 3 -1 roll setfileposition
  862.   /FontDescriptor oget /FontName oget findfont
  863.   adjustfont
  864. } bdef
  865.  
  866. % Read an embedded CFF CIDFont.
  867. /readCIDFontType0C {  % <font-resource> <stream-dict> readCIDFontType0C <font>
  868.   PDFfile fileposition 3 1 roll
  869.   dup true resolvestream dup readfontfilter
  870.         % Stack: pos resource streamdict stream filter
  871.   3 index /FontDescriptor oget /FontName oget
  872.   1 index FRD
  873.   closefile closefile pop
  874.   PDFfile 3 -1 roll setfileposition
  875.         % Some broken Adobe software produces PDF files in which
  876.         % the FontName of the CFF font and the FontName in the
  877.         % FontDescriptor don't match the BaseFont in the font.
  878.         % Use the FontName, rather than the BaseFont, here.
  879.   dup /FontDescriptor oget /FontName oget /CIDFont findresource
  880.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  881. } bdef
  882.  
  883. % ---------------- Font lookup ---------------- %
  884.  
  885. /fonttypeprocs mark        % <font-resource> -proc- <font>
  886.   /Type0 /buildType0 cvx
  887.   /Type1 /buildType1 cvx
  888.   /MMType1 1 index
  889.   /Type3 /buildType3 cvx
  890.   /TrueType /buildTrueType cvx
  891.   /CIDFontType0 /buildCIDType0 cvx
  892.   /CIDFontType2 /buildCIDType2 cvx
  893. .dicttomark readonly def
  894.  
  895. /resourcefont            % <font-resource> resourcefont <font>
  896.  { dup /PSFont .knownget
  897.     { /FID .knownget { type /fonttype eq } { false } ifelse }
  898.     { false }
  899.    ifelse
  900.     { /PSFont get
  901.     }
  902.     { dup dup /FontDescriptor knownoget
  903.        {    % Stack: font-res font-res font-desc
  904.      dup /FontFile knownoget
  905.       { exch pop readtype1 true }
  906.       { dup /FontFile2 knownoget
  907.          { exch pop readtruetype true }
  908.          { /FontFile3 knownoget
  909.         { dup /Subtype get fontloadprocs exch get exec true }
  910.         { false }
  911.            ifelse
  912.          }
  913.         ifelse
  914.       }
  915.      ifelse
  916.        }
  917.        { false }
  918.       ifelse
  919.         % Stack: font-res font-res false
  920.         %  -or-: font-res font true
  921.       not
  922.        { dup /Subtype get fonttypeprocs exch get exec }
  923.       if
  924.       2 copy /PSFont exch put
  925.       exch pop
  926.     }
  927.    ifelse
  928.  } bdef
  929.  
  930. drawopdict begin
  931.   /d0 {
  932.     .adjustcharwidth setcharwidth
  933.   } bdef
  934.   /d1 {
  935.     6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  936.   } bdef
  937.   /Tf {
  938.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  939.     resourcefont exch Tf pop
  940.   } bdef
  941. end
  942.  
  943. end            % pdfdict
  944. end            % GS_PDF_ProcSet
  945. .setglobal
  946.